import csv
from typing import List, Dict, Optional, Union, Any
import json
import pprint
from pathlib import Path
import os
from common.logger_ctrl import mylogger


def extract_csv_data(
        file_path: str,
        delimiter: str = ',',
        header: bool = True,
        encoding: str = 'utf-8',
        quotechar: str = '"',
        max_rows: Optional[int] = None,
        filters: Optional[Dict[str, Union[str, int, float]]] = None
) -> List[Dict[str, str]]:
    """
    从 CSV 文件中提取数据并返回字典列表

    参数:
        file_path: CSV 文件路径
        delimiter: 分隔符，默认为逗号
        header: 是否包含表头，默认为 True
        encoding: 文件编码，默认为 utf-8
        quotechar: 引号字符，默认为双引号
        max_rows: 最大提取行数，None 表示不限制
        filters: 过滤条件，字典格式，如 {"column_name": "value"}

    返回:
        包含每行数据的字典列表，若无表头则键为列索引（如 "0", "1"）
    """
    data = []

    try:
        with open(file_path, 'r', encoding=encoding) as file:
            reader = csv.reader(file, delimiter=delimiter, quotechar=quotechar)

            # 读取表头（如果有）
            if header:
                headers = next(reader)
            else:
                # 如果没有表头，使用索引作为键
                first_row = next(reader)
                headers = [str(i) for i in range(len(first_row))]
                data.append(dict(zip(headers, first_row)))

            # 逐行读取数据
            row_count = 0
            for row in reader:
                # 检查是否达到最大行数限制
                if max_rows is not None and row_count >= max_rows:
                    break

                # 转换为字典
                row_dict = dict(zip(headers, row))

                # 应用过滤条件
                if filters:
                    match = True
                    for key, value in filters.items():
                        if key not in row_dict or row_dict[key] != str(value):
                            match = False
                            break
                    if not match:
                        continue

                data.append(row_dict)
                row_count += 1

        return data

    except FileNotFoundError:
        raise FileNotFoundError(f"CSV file not found: {file_path}")
    except Exception as e:
        raise Exception(f"Error reading CSV file: {str(e)}")


def pretty_print(data: Any, format: str = "auto", indent: int = 4,
                 sort_keys: bool = False, ensure_ascii: bool = False) -> str:
    """
    美观地格式化JSON或字典对象并返回字符串

    Args:
        data: 需要格式化的数据（字典、列表或JSON字符串）
        format: 输出格式，可选值：
            - "auto": 自动检测（优先JSON，其次字典）
            - "json": 格式化为JSON字符串
            - "dict": 格式化为字典格式
        indent: 缩进空格数（仅对json和dict格式有效）
        sort_keys: 是否按键排序（仅对json格式有效）
        ensure_ascii: 是否确保ASCII编码（仅对json格式有效）

    Returns:
        格式化后的字符串
    """
    # 处理JSON字符串输入
    if isinstance(data, str):
        try:
            data = json.loads(data)
        except json.JSONDecodeError:
            pass  # 如果不是有效JSON，按原始字符串处理

    # 根据指定格式处理并返回字符串
    if format == "json":
        try:
            return json.dumps(data, indent=indent, sort_keys=sort_keys, ensure_ascii=ensure_ascii)
        except TypeError:
            # 处理非JSON可序列化对象
            class CustomEncoder(json.JSONEncoder):
                def default(self, obj):
                    return str(obj)  # 简单地将不可序列化对象转为字符串

            return json.dumps(data, indent=indent, sort_keys=sort_keys,
                              ensure_ascii=ensure_ascii, cls=CustomEncoder)

    elif format == "dict":
        return pprint.pformat(data, indent=indent)

    else:  # 默认为auto
        if isinstance(data, (dict, list)):
            try:
                # 尝试JSON格式（更美观）
                return json.dumps(data, indent=indent, sort_keys=sort_keys, ensure_ascii=ensure_ascii)
            except TypeError:
                # 非JSON可序列化对象使用pprint格式
                return pprint.pformat(data, indent=indent)
        else:
            # 非字典/列表类型直接返回字符串表示
            return str(data)


def convert_to_bytes(size_str):
    # 定义单位及其对应的字节倍数
    units = {
        'B': 1,
        'K': 1024,
        'M': 1024 ** 2,
        'G': 1024 ** 3,
        'T': 1024 ** 4,
        'P': 1024 ** 5,
    }
    # 去除输入字符串两端的空白字符,删除最小单位B
    size_str = size_str.strip().upper().rstrip("B")

    for unit, multiplier in units.items():
        if size_str.endswith(unit):
            # 提取数字部分
            size_num = size_str[:-len(unit)]  # 截断单位，保留数字部分
            return float(size_num) * multiplier
    # 如果输入没有匹配到任何单位，默认按字节处理
    try:
        return float(size_str)
    except ValueError:
        print(f"Invalid input: {size_str}. Please provide a valid size with or without a unit.")
        return None


def is_container_environment():
    """快速检测是否在容器环境中"""

    # 1. 检查Docker特有文件
    if Path("/.dockerenv").exists():
        return True, "Docker容器"

    # 2. 检查cgroup
    cgroup_path = Path("/proc/1/cgroup")
    if cgroup_path.exists():
        with open(cgroup_path, 'r') as f:
            if any(keyword in f.read() for keyword in ['docker', 'kubepods', 'containerd']):
                return True, "容器环境(cgroup)"

    # 3. 检查Kubernetes环境变量
    if 'KUBERNETES_SERVICE_HOST' in os.environ:
        return True, "Kubernetes Pod"

    # 4. 检查Kubernetes服务账户
    if Path("/var/run/secrets/kubernetes.io/serviceaccount/token").exists():
        return True, "Kubernetes服务账户"

    return False, "宿主机环境"


if __name__ == '__main__':
    print(convert_to_bytes('10.00K'))
